#include<stdio.h>
int main()
{
	printf("hah\n");
	return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>

// //僵尸进程：父进程没退出，子进程退出且父进程没wait/waitpid子进程的状态，那么这样的子进程就是僵尸进程
// int main()
// {
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 	}else{                      //parent process
// 		wait();
// 		printf("parent\n");
// 		while(1)sleep(1);
// 	}
// 	return 0;
// }

// int main()        //虽然fork之后，父子进程执行先后顺序不确定；但是在centos6.5是先执行父进程再执行子进程的。
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 		usleep(500000);
// 	}else{                      //parent process
// 		printf("parent\n");
// 		//wait();//阻塞式等待
// 		sleep(1);
// 		waitpid(-1,NULL,WNOHANG);//此时是非阻塞式等待。注意，非阻塞等待假如先执行，然后子进程再退出，那么最后子进程依然会变成僵尸进程
// 		int i = 1;
// 		while(i){
// 			sleep(1);
// 			printf("%d\n",i++);
// 		}
// 	}
// 	return 0;
// }

int main()
{
	pid_t pid = fork();                                                       //第一次fork()
	if(pid < 0)exit(1);

	if(pid == 0){               //child process
		printf("child pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);

		pid_t id = fork();                                                 //第二次fork()    让孙子进程变成孤儿进程
		if(id == 0){      //the second child
			printf("the second child pid = %d,ppid = %d\n",getpid(),getppid());
			int i = 1;
			while(i){
				sleep(1);
				printf("the second child %d  pid = %d,ppid = %d\n",i++,getpid(),getppid());
				usleep(500000);
			}
		}else{
			sleep(1); //子进程先睡一秒，确保孙进程先运行
		}
	}else{                      //parent process
		printf("parent pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);
		wait(NULL);//阻塞式等待
		//sleep(1);
		//waitpid(-1,NULL,WNOHANG);
		int i1 = 1;
		while(i1){
			sleep(1);
			printf("parent %d pid = %d,ppid = %d\n",i1++,getpid(),getppid());
		usleep(500000);
		}
	}
	return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>

// //僵尸进程：父进程没退出，子进程退出且父进程没wait/waitpid子进程的状态，那么这样的子进程就是僵尸进程
// int main()
// {
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 	}else{                      //parent process
// 		wait();
// 		printf("parent\n");
// 		while(1)sleep(1);
// 	}
// 	return 0;
// }

// int main()        //虽然fork之后，父子进程执行先后顺序不确定；但是在centos6.5是先执行父进程再执行子进程的。
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 		usleep(500000);
// 	}else{                      //parent process
// 		printf("parent\n");
// 		//wait();//阻塞式等待
// 		sleep(1);
// 		waitpid(-1,NULL,WNOHANG);//此时是非阻塞式等待。注意，非阻塞等待假如先执行，然后子进程再退出，那么最后子进程依然会变成僵尸进程
// 		int i = 1;
// 		while(i){
// 			sleep(1);
// 			printf("%d\n",i++);
// 		}
// 	}
// 	return 0;
// }

int main()
{
	pid_t pid = fork();                                                       //第一次fork()
	if(pid < 0)exit(1);

	if(pid == 0){               //child process
		printf("child pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);

		pid_t id = fork();                                                 //第二次fork()    让孙子进程变成孤儿进程
		if(id == 0){      //the second child
			printf("the second child pid = %d,ppid = %d\n",getpid(),getppid());
			int i = 1;
			while(i){
				sleep(1);
				printf("the second child %d  pid = %d,ppid = %d\n",i++,getpid(),getppid());
				usleep(500000);
			}
		}else{
			sleep(1); //子进程先睡一秒，确保孙进程先运行
		}
	}else{                      //parent process
		printf("parent pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);
		wait(NULL);//阻塞式等待
		//sleep(1);
		//waitpid(-1,NULL,WNOHANG);
		int i1 = 1;
		while(i1){
			sleep(1);
			printf("parent %d pid = %d,ppid = %d\n",i1++,getpid(),getppid());
		usleep(500000);
		}
	}
	return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>

// //僵尸进程：父进程没退出，子进程退出且父进程没wait/waitpid子进程的状态，那么这样的子进程就是僵尸进程
// int main()
// {
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 	}else{                      //parent process
// 		wait();
// 		printf("parent\n");
// 		while(1)sleep(1);
// 	}
// 	return 0;
// }

// int main()        //虽然fork之后，父子进程执行先后顺序不确定；但是在centos6.5是先执行父进程再执行子进程的。
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 		usleep(500000);
// 	}else{                      //parent process
// 		printf("parent\n");
// 		//wait();//阻塞式等待
// 		sleep(1);
// 		waitpid(-1,NULL,WNOHANG);//此时是非阻塞式等待。注意，非阻塞等待假如先执行，然后子进程再退出，那么最后子进程依然会变成僵尸进程
// 		int i = 1;
// 		while(i){
// 			sleep(1);
// 			printf("%d\n",i++);
// 		}
// 	}
// 	return 0;
// }

int main()
{
	pid_t pid = fork();                                                       //第一次fork()
	if(pid < 0)exit(1);

	if(pid == 0){               //child process
		printf("child pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);

		pid_t id = fork();                                                 //第二次fork()    让孙子进程变成孤儿进程
		if(id == 0){      //the second child
			printf("the second child pid = %d,ppid = %d\n",getpid(),getppid());
			int i = 1;
			while(i){
				sleep(1);
				printf("the second child %d  pid = %d,ppid = %d\n",i++,getpid(),getppid());
				usleep(500000);
			}
		}else{
			sleep(1); //子进程先睡一秒，确保孙进程先运行
		}
	}else{                      //parent process
		printf("parent pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);
		wait(NULL);//阻塞式等待
		//sleep(1);
		//waitpid(-1,NULL,WNOHANG);
		int i1 = 1;
		while(i1){
			sleep(1);
			printf("parent %d pid = %d,ppid = %d\n",i1++,getpid(),getppid());
		usleep(500000);
		}
	}
	return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>

// //僵尸进程：父进程没退出，子进程退出且父进程没wait/waitpid子进程的状态，那么这样的子进程就是僵尸进程
// int main()
// {
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 	}else{                      //parent process
// 		wait();
// 		printf("parent\n");
// 		while(1)sleep(1);
// 	}
// 	return 0;
// }

// int main()        //虽然fork之后，父子进程执行先后顺序不确定；但是在centos6.5是先执行父进程再执行子进程的。
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 		usleep(500000);
// 	}else{                      //parent process
// 		printf("parent\n");
// 		//wait();//阻塞式等待
// 		sleep(1);
// 		waitpid(-1,NULL,WNOHANG);//此时是非阻塞式等待。注意，非阻塞等待假如先执行，然后子进程再退出，那么最后子进程依然会变成僵尸进程
// 		int i = 1;
// 		while(i){
// 			sleep(1);
// 			printf("%d\n",i++);
// 		}
// 	}
// 	return 0;
// }

int main()
{
	pid_t pid = fork();                                                       //第一次fork()
	if(pid < 0)exit(1);

	if(pid == 0){               //child process
		printf("child pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);

		pid_t id = fork();                                                 //第二次fork()    让孙子进程变成孤儿进程
		if(id == 0){      //the second child
			printf("the second child pid = %d,ppid = %d\n",getpid(),getppid());
			int i = 1;
			while(i){
				sleep(1);
				printf("the second child %d  pid = %d,ppid = %d\n",i++,getpid(),getppid());
				usleep(500000);
			}
		}else{
			sleep(1); //子进程先睡一秒，确保孙进程先运行
		}
	}else{                      //parent process
		printf("parent pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);
		wait(NULL);//阻塞式等待
		//sleep(1);
		//waitpid(-1,NULL,WNOHANG);
		int i1 = 1;
		while(i1){
			sleep(1);
			printf("parent %d pid = %d,ppid = %d\n",i1++,getpid(),getppid());
		usleep(500000);
		}
	}
	return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>

// //僵尸进程：父进程没退出，子进程退出且父进程没wait/waitpid子进程的状态，那么这样的子进程就是僵尸进程
// int main()
// {
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 	}else{                      //parent process
// 		wait();
// 		printf("parent\n");
// 		while(1)sleep(1);
// 	}
// 	return 0;
// }

// int main()        //虽然fork之后，父子进程执行先后顺序不确定；但是在centos6.5是先执行父进程再执行子进程的。
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 		usleep(500000);
// 	}else{                      //parent process
// 		printf("parent\n");
// 		//wait();//阻塞式等待
// 		sleep(1);
// 		waitpid(-1,NULL,WNOHANG);//此时是非阻塞式等待。注意，非阻塞等待假如先执行，然后子进程再退出，那么最后子进程依然会变成僵尸进程
// 		int i = 1;
// 		while(i){
// 			sleep(1);
// 			printf("%d\n",i++);
// 		}
// 	}
// 	return 0;
// }

int main()
{
	pid_t pid = fork();                                                       //第一次fork()
	if(pid < 0)exit(1);

	if(pid == 0){               //child process
		printf("child pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);

		pid_t id = fork();                                                 //第二次fork()    让孙子进程变成孤儿进程
		if(id == 0){      //the second child
			printf("the second child pid = %d,ppid = %d\n",getpid(),getppid());
			int i = 1;
			while(i){
				sleep(1);
				printf("the second child %d  pid = %d,ppid = %d\n",i++,getpid(),getppid());
				usleep(500000);
			}
		}else{
			sleep(1); //子进程先睡一秒，确保孙进程先运行
		}
	}else{                      //parent process
		printf("parent pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);
		wait(NULL);//阻塞式等待
		//sleep(1);
		//waitpid(-1,NULL,WNOHANG);
		int i1 = 1;
		while(i1){
			sleep(1);
			printf("parent %d pid = %d,ppid = %d\n",i1++,getpid(),getppid());
		usleep(500000);
		}
	}
	return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>

// //僵尸进程：父进程没退出，子进程退出且父进程没wait/waitpid子进程的状态，那么这样的子进程就是僵尸进程
// int main()
// {
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 	}else{                      //parent process
// 		wait();
// 		printf("parent\n");
// 		while(1)sleep(1);
// 	}
// 	return 0;
// }

// int main()        //虽然fork之后，父子进程执行先后顺序不确定；但是在centos6.5是先执行父进程再执行子进程的。
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 		usleep(500000);
// 	}else{                      //parent process
// 		printf("parent\n");
// 		//wait();//阻塞式等待
// 		sleep(1);
// 		waitpid(-1,NULL,WNOHANG);//此时是非阻塞式等待。注意，非阻塞等待假如先执行，然后子进程再退出，那么最后子进程依然会变成僵尸进程
// 		int i = 1;
// 		while(i){
// 			sleep(1);
// 			printf("%d\n",i++);
// 		}
// 	}
// 	return 0;
// }

int main()
{
	pid_t pid = fork();                                                       //第一次fork()
	if(pid < 0)exit(1);

	if(pid == 0){               //child process
		printf("child pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);

		pid_t id = fork();                                                 //第二次fork()    让孙子进程变成孤儿进程
		if(id == 0){      //the second child
			printf("the second child pid = %d,ppid = %d\n",getpid(),getppid());
			int i = 1;
			while(i){
				sleep(1);
				printf("the second child %d  pid = %d,ppid = %d\n",i++,getpid(),getppid());
				usleep(500000);
			}
		}else{
			sleep(1); //子进程先睡一秒，确保孙进程先运行
		}
	}else{                      //parent process
		printf("parent pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);
		wait(NULL);//阻塞式等待
		//sleep(1);
		//waitpid(-1,NULL,WNOHANG);
		int i1 = 1;
		while(i1){
			sleep(1);
			printf("parent %d pid = %d,ppid = %d\n",i1++,getpid(),getppid());
		usleep(500000);
		}
	}
	return 0;
}
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>

// //僵尸进程：父进程没退出，子进程退出且父进程没wait/waitpid子进程的状态，那么这样的子进程就是僵尸进程
// int main()
// {
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 	}else{                      //parent process
// 		wait();
// 		printf("parent\n");
// 		while(1)sleep(1);
// 	}
// 	return 0;
// }

// int main()        //虽然fork之后，父子进程执行先后顺序不确定；但是在centos6.5是先执行父进程再执行子进程的。
// 	pid_t pid = fork();
// 	if(pid < 0)exit(1);
// 
// 	if(pid == 0){               //child process
// 		printf("child\n");
// 		usleep(500000);
// 	}else{                      //parent process
// 		printf("parent\n");
// 		//wait();//阻塞式等待
// 		sleep(1);
// 		waitpid(-1,NULL,WNOHANG);//此时是非阻塞式等待。注意，非阻塞等待假如先执行，然后子进程再退出，那么最后子进程依然会变成僵尸进程
// 		int i = 1;
// 		while(i){
// 			sleep(1);
// 			printf("%d\n",i++);
// 		}
// 	}
// 	return 0;
// }

int main()
{
	pid_t pid = fork();                                                       //第一次fork()
	if(pid < 0)exit(1);

	if(pid == 0){               //child process
		printf("child pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);

		pid_t id = fork();                                                 //第二次fork()    让孙子进程变成孤儿进程
		if(id == 0){      //the second child
			printf("the second child pid = %d,ppid = %d\n",getpid(),getppid());
			int i = 1;
			while(i){
				sleep(1);
				printf("the second child %d  pid = %d,ppid = %d\n",i++,getpid(),getppid());
				usleep(500000);
			}
		}else{
			sleep(1); //子进程先睡一秒，确保孙进程先运行
		}
	}else{                      //parent process
		printf("parent pid = %d,ppid = %d\n",getpid(),getppid());
		usleep(500000);
		wait(NULL);//阻塞式等待
		//sleep(1);
		//waitpid(-1,NULL,WNOHANG);
		int i1 = 1;
		while(i1){
			sleep(1);
			printf("parent %d pid = %d,ppid = %d\n",i1++,getpid(),getppid());
		usleep(500000);
		}
	}
	return 0;
}
